package com.example.wzdjcrdpassword.service;

import com.example.wzdjcrdpassword.cache.SystemCacheManager;
import com.example.wzdjcrdpassword.entity.SystemEntity;
import com.example.wzdjcrdpassword.repository.SystemRepository;
import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class SystemService {
    
    private final SystemRepository systemRepository;

    @Resource
    @Lazy
    private SystemCacheManager systemCacheManager;
    
    /**
     * 获取所有有效的系统
     * @return 系统列表
     */
    public List<SystemEntity> getAllActiveSystems() {
        // 从缓存获取所有系统
        List<SystemEntity> cachedSystems = systemCacheManager.getAllSystemsFromCache();
        if (!cachedSystems.isEmpty()) {
            return cachedSystems;
        }
        
        // 缓存为空，从数据库查询并更新缓存
        List<SystemEntity> systems = systemRepository.findAllActiveSystems();
        if (!systems.isEmpty()) {
            // 更新缓存
            systemCacheManager.refreshCache();
        }
        return systems;
    }
    
    /**
     * 根据系统ID获取系统信息
     * @param systemId 系统ID
     * @return 系统信息
     */
    public Optional<SystemEntity> getSystemById(String systemId) {
        // 优先从缓存获取
        Optional<SystemEntity> cachedSystem = systemCacheManager.getSystemFromCache(systemId);
        if (cachedSystem.isPresent()) {
            return cachedSystem;
        }
        
        // 缓存中没有，从数据库查询
        Optional<SystemEntity> system = systemRepository.findBySystemIdAndIsDeleted(systemId, "NO");
        
        // 如果数据库中存在，更新到缓存
        system.ifPresent(systemCacheManager::addSystemToCache);
        
        return system;
    }
    
    /**
     * 根据系统类型获取系统列表
     * @param systemType 系统类型
     * @return 系统列表
     */
    public List<SystemEntity> getSystemsByType(String systemType) {
        // 优先从缓存获取
        List<SystemEntity> cachedSystems = systemCacheManager.getSystemsByTypeFromCache(systemType);
        if (!cachedSystems.isEmpty()) {
            return cachedSystems;
        }
        
        // 缓存中没有，从数据库查询
        List<SystemEntity> systems = systemRepository.findBySystemTypeAndIsDeleted(systemType, "NO");
        
        // 如果数据库中存在，更新到缓存
        if (!systems.isEmpty()) {
            systems.forEach(systemCacheManager::addSystemToCache);
        }
        
        return systems;
    }
    
    /**
     * 根据系统名称模糊查询
     * @param systemName 系统名称
     * @return 系统列表
     */
    public List<SystemEntity> searchSystemsByName(String systemName) {
        return systemRepository.findBySystemNameContainingAndIsDeleted(systemName, "NO");
    }
    
    /**
     * 根据系统类型和系统ID获取系统信息
     * @param systemType 系统类型
     * @param systemId 系统ID
     * @return 系统信息
     */
    public Optional<SystemEntity> getSystemByTypeAndId(String systemType, String systemId) {
        return systemRepository.findBySystemTypeAndSystemId(systemType, systemId);
    }
    
    /**
     * 创建新系统
     * @param systemEntity 系统实体
     * @return 保存后的系统
     */
    public SystemEntity createSystem(SystemEntity systemEntity) {
        SystemEntity savedSystem = systemRepository.save(systemEntity);
        // 添加到缓存
        systemCacheManager.addSystemToCache(savedSystem);
        return savedSystem;
    }
    
    /**
     * 更新系统信息
     * @param systemEntity 系统实体
     * @return 更新后的系统
     */
    public SystemEntity updateSystem(SystemEntity systemEntity) {
        SystemEntity savedSystem = systemRepository.save(systemEntity);
        // 更新缓存
        if ("NO".equals(savedSystem.getIsDeleted())) {
            systemCacheManager.addSystemToCache(savedSystem);
        } else {
            systemCacheManager.removeSystemFromCache(savedSystem.getSystemId());
        }
        return savedSystem;
    }
    
    /**
     * 逻辑删除系统
     * @param systemId 系统ID
     * @return 是否删除成功
     */
    public boolean deleteSystem(String systemId) {
        Optional<SystemEntity> systemOpt = systemRepository.findBySystemIdAndIsDeleted(systemId, "NO");
        if (systemOpt.isPresent()) {
            SystemEntity system = systemOpt.get();
            system.setIsDeleted("YES");
            systemRepository.save(system);
            // 从缓存中移除
            systemCacheManager.removeSystemFromCache(systemId);
            return true;
        }
        return false;
    }
}